/**
 * Technical Update - 技术更新汇总功能
 * 功能：将所有内容更新功能的结果汇总到Word模板中
 */

// 导入用户数据监控模块 - 浏览器环境兼容
// 在浏览器环境中，这些模块将通过全局变量或动态加载方式获取
let manifest = null;

// 获取监控数据发送函数
function getSendMonitoringData() {
    if (typeof window !== 'undefined') {
        // 浏览器环境 - 直接使用window.sendMonitoringData
        return window.sendMonitoringData || function(data) {
            console.log('用户数据监控:', data);
            return Promise.resolve();
        };
    } else {
        // Node.js环境
        try {
            const userData = require("./user-data.js");
            return userData.sendMonitoringData;
        } catch (err) {
            console.warn('无法加载模块:', err.message);
            return function(data) {
                console.log('用户数据监控:', data);
                return Promise.resolve();
            };
        }
    }
}

// 获取manifest信息
if (typeof window !== 'undefined') {
    manifest = window.manifest || {
        id: "info-update",
        name: "Information Update",
        version: "1.0.0"
    };
} else {
    try {
        manifest = require('../manifest.json');
    } catch (err) {
        manifest = {
            id: "info-update",
            name: "Information Update",
            version: "1.0.0"
        };
    }
}

// 数据源配置
const DATA_SOURCES = {
    astm: {
        name: 'ASTM数据',
        path: 'astm/data/',
        statusId: 'astm-status',
        checkboxId: 'astm-checkbox'
    },
    govinfo: {
        name: 'Govinfo数据',
        path: 'govinfo/data/',
        statusId: 'govinfo-status',
        checkboxId: 'govinfo-checkbox'
    },
    cen: {
        name: 'CEN数据',
        path: 'cen/data/',
        statusId: 'cen-status',
        checkboxId: 'cen-checkbox'
    },
    eucommission: {
        name: 'EU Commission数据',
        path: 'eucommission/data/',
        statusId: 'eu-status',
        checkboxId: 'eu-checkbox'
    }
};

// 全局变量
let logManager;
let detectedDataSources = {};

/**
 * 初始化Technical Update功能
 */
function initTechUpdate() {
    console.log('Technical Update: 开始初始化模块');
    
    // 初始化日志管理器
    const logElement = document.getElementById('tech-update-log');
    if (logElement) {
        logManager = {
            addLog: (message, type = 'info') => {
                const timestamp = new Date().toLocaleTimeString();
                const logEntry = `[${timestamp}] ${message}`;
                logElement.innerHTML += `<div class="log-entry log-${type}">${logEntry}</div>`;
                logElement.scrollTop = logElement.scrollHeight;
            },
            clear: () => {
                logElement.innerHTML = '等待操作...';
            }
        };
        console.log('Technical Update: 日志管理器已初始化');
    } else {
        console.warn('Technical Update: tech-update-log 元素未找到');
    }

    // 绑定事件监听器
    bindEventListeners();
    
    // 设置默认模板路径 - 使用绝对路径
    const defaultTemplatePath = 'src/plugins/info-update/tech-update/template.docx';
    const templatePathInput = document.getElementById('techUpdateTemplatePath');
    if (templatePathInput) {
        templatePathInput.value = defaultTemplatePath;
        console.log('Technical Update: 默认模板路径已设置');
    } else {
        console.error('Technical Update: techUpdateTemplatePath 元素未找到！');
    }
    
    // 初始化日期筛选控件
    const filterYear = document.getElementById('filterYear');
    const filterMonth = document.getElementById('filterMonth');
    
    if (filterYear) {
        console.log('Technical Update: 年份输入框已初始化');
    } else {
        console.warn('Technical Update: filterYear 元素未找到');
    }
    
    if (filterMonth) {
        console.log('Technical Update: 月份选择器已初始化');
    } else {
        console.warn('Technical Update: filterMonth 元素未找到');
    }
    
    addLog('Technical Update 功能已初始化，默认模板路径和日期筛选控件已设置', 'info');
    console.log('Technical Update: 模块初始化完成');
}

/**
 * 绑定事件监听器
 */
function bindEventListeners() {
    console.log('Technical Update: 开始绑定事件监听器');
    
    // 注意：checkDataSourcesBtn 的事件绑定已在 info-update.js 中处理，避免重复绑定
    console.log('Technical Update: checkDataSourcesBtn 事件由 info-update.js 处理');

    // 选择模板文件按钮
    const selectTemplateBtn = document.getElementById('selectTemplateBtn');
    if (selectTemplateBtn) {
        // 移除可能存在的旧事件监听器
        selectTemplateBtn.removeEventListener('click', selectTemplateFile);
        selectTemplateBtn.addEventListener('click', selectTemplateFile);
        console.log('Technical Update: selectTemplateBtn 事件已绑定');
        console.log('selectTemplateBtn 元素:', selectTemplateBtn);
    } else {
        console.warn('Technical Update: selectTemplateBtn 元素未找到');
        // 尝试查找所有可能的按钮元素
        const allButtons = document.querySelectorAll('button');
        console.log('页面中所有按钮元素:', allButtons);
    }

    // 选择输出目录按钮
    const selectOutputBtn = document.getElementById('selectOutputBtn');
    if (selectOutputBtn) {
        // 移除可能存在的旧事件监听器
        selectOutputBtn.removeEventListener('click', selectOutputDirectory);
        selectOutputBtn.addEventListener('click', selectOutputDirectory);
        console.log('Technical Update: selectOutputBtn 事件已绑定');
        console.log('selectOutputBtn 元素:', selectOutputBtn);
    } else {
        console.warn('Technical Update: selectOutputBtn 元素未找到');
    }

    // 生成技术更新报告按钮
    const generateBtn = document.getElementById('generateTechUpdateBtn');
    if (generateBtn) {
        generateBtn.addEventListener('click', generateTechUpdateReport);
        console.log('Technical Update: generateTechUpdateBtn 事件已绑定');
    } else {
        console.error('Technical Update: generateTechUpdateBtn 元素未找到！');
    }

    // 重置按钮
    const resetBtn = document.getElementById('resetTechUpdateBtn');
    if (resetBtn) {
        resetBtn.addEventListener('click', resetTechUpdate);
        console.log('Technical Update: resetTechUpdateBtn 事件已绑定');
    } else {
        console.warn('Technical Update: resetTechUpdateBtn 元素未找到');
    }
    
    // 日期筛选控件事件监听器
    const filterYear = document.getElementById('filterYear');
    const filterMonth = document.getElementById('filterMonth');
    
    if (filterYear) {
        filterYear.addEventListener('input', function() {
            const inputYear = this.value.trim();
            if (inputYear) {
                // 验证年份格式
                const year = parseInt(inputYear);
                if (isNaN(year) || year < 1900 || year > 2100) {
                    addLog('请输入有效的年份（1900-2100）', 'warning');
                } else {
                    addLog(`已设置筛选年份: ${year}`, 'info');
                }
            } else {
                addLog('已取消年份筛选', 'info');
            }
        });
        console.log('Technical Update: filterYear 事件已绑定');
    } else {
        console.warn('Technical Update: filterYear 元素未找到');
    }
    
    if (filterMonth) {
        filterMonth.addEventListener('change', function() {
            const selectedMonth = this.value;
            if (selectedMonth) {
                addLog(`已选择筛选月份: ${selectedMonth}月`, 'info');
            } else {
                addLog('已取消月份筛选', 'info');
            }
        });
        console.log('Technical Update: filterMonth 事件已绑定');
    } else {
        console.warn('Technical Update: filterMonth 元素未找到');
    }
    
    // 清空日志按钮
    const clearLogBtn = document.getElementById('clear-tech-update-log-btn');
    if (clearLogBtn) {
        clearLogBtn.addEventListener('click', function() {
            if (logManager && logManager.clear) {
                logManager.clear();
                console.log('Technical Update: 日志已清空');
            }
        });
        console.log('Technical Update: clearLogBtn 事件已绑定');
    } else {
        console.warn('Technical Update: clear-tech-update-log-btn 元素未找到');
    }
    
    console.log('Technical Update: 事件监听器绑定完成');
}

/**
 * 检测数据源
 */
async function checkDataSources() {
    addLog('开始检测数据源...', 'info');
    
    for (const [key, source] of Object.entries(DATA_SOURCES)) {
        const statusElement = document.getElementById(source.statusId);
        const sourceItem = statusElement.closest('.source-item');
        const checkboxElement = document.getElementById(source.checkboxId);
        
        // 设置检测中状态
        statusElement.textContent = '检测中...';
        statusElement.className = 'source-status checking';
        sourceItem.className = 'source-item checking';
        
        try {
            // 检测数据文件是否存在
            const fileInfo = await checkDataSourceExists(source.path);
            
            if (fileInfo && fileInfo.exists) {
                const modifiedDate = new Date(fileInfo.modifiedTime).toLocaleString('zh-CN');
                statusElement.textContent = `已检测到 (${modifiedDate})`;
                statusElement.className = 'source-status detected';
                sourceItem.className = 'source-item detected';
                detectedDataSources[key] = true;
                
                // 显示并启用勾选框，默认勾选
                checkboxElement.style.display = 'inline-block';
                checkboxElement.disabled = false;
                checkboxElement.checked = true;
                
                addLog(`${source.name}: 检测到数据文件 - ${fileInfo.fileName} (修改时间: ${modifiedDate})`, 'success');
            } else {
                statusElement.textContent = '未检测到';
                statusElement.className = 'source-status not-detected';
                sourceItem.className = 'source-item not-detected';
                detectedDataSources[key] = false;
                
                // 隐藏勾选框
                checkboxElement.style.display = 'none';
                checkboxElement.disabled = true;
                checkboxElement.checked = false;
                
                // 显示具体的未检测到原因
                const reason = fileInfo && fileInfo.reason ? fileInfo.reason : '未检测到JSON数据文件';
                addLog(`${source.name}: ${reason}`, 'warning');
            }
        } catch (error) {
            statusElement.textContent = '检测失败';
            statusElement.className = 'source-status not-detected';
            sourceItem.className = 'source-item not-detected';
            detectedDataSources[key] = false;
            
            // 隐藏勾选框
            checkboxElement.style.display = 'none';
            checkboxElement.disabled = true;
            checkboxElement.checked = false;
            
            addLog(`${source.name}: 检测失败 - ${error.message}`, 'error');
        }
        
        // 添加延迟以显示检测过程
        await new Promise(resolve => setTimeout(resolve, 500));
    }
    
    addLog('数据源检测完成', 'info');
}

/**
 * 检查数据源是否存在
 */
async function checkDataSourceExists(sourcePath) {
    try {
        console.log(`检查数据源路径: ${sourcePath}`);
        
        // 直接使用相对路径检查JSON文件
        return await checkJsonFilesInDirectory(sourcePath);
    } catch (error) {
        console.error('检查数据源失败:', error);
        return { exists: false, reason: error.message };
    }
}

/**
 * 检查目录中的JSON文件
 */
async function checkJsonFilesInDirectory(dirPath) {
    try {
        console.log(`正在检查目录: ${dirPath}`);
        
        // 根据实际文件系统结构检查JSON文件
        if (dirPath.includes('astm/data/')) {
            // ASTM目录：动态检测JSON文件
            return await findJsonFilesInDirectory(dirPath, 'astm');
        } else if (dirPath.includes('govinfo/data/')) {
            // Govinfo目录：动态检测JSON文件
            return await findJsonFilesInDirectory(dirPath, 'govinfo');
        } else if (dirPath.includes('cen/data/')) {
            return await findJsonFilesInDirectory(dirPath, 'cen');
            // CEN目录下没有data文件夹
            // return { exists: false, reason: 'CEN目录下不存在data文件夹' };
        } else if (dirPath.includes('eucommission/data/')) {
            return await findJsonFilesInDirectory(dirPath, 'eucommission');
            // EU Commission目录下没有data文件夹
            // return { exists: false, reason: 'EU Commission目录下不存在data文件夹' };
        }
        
        return { exists: false, reason: '未知的数据源路径' };
    } catch (error) {
        console.error('检查JSON文件失败:', error);
        return { exists: false, reason: error.message };
    }
}

/**
 * 检查特定的JSON文件
 */
/**
 * 动态查找目录中的JSON文件
 */
async function findJsonFilesInDirectory(dirPath, sourceType) {
    try {
        // 构建从项目根目录到目标目录的相对路径
        // 当前工作目录是项目根目录，需要指向 src/plugins/info-update/目录下的数据文件
        const relativePath = `src/plugins/info-update/${dirPath}`;
        console.log(`尝试检测 ${sourceType} 的JSON文件，目标目录: ${dirPath}`);
        console.log(`构建的相对路径: ${relativePath}`);
        console.log(`完整路径解析: 项目根目录 -> ${relativePath}`);
        
        // 直接检测目录中的JSON文件
        const result = await checkDirectoryForJsonFiles(relativePath);
        if (result.exists) {
            return result;
        }
        
        // 如果没有找到JSON文件，返回未找到
        return { 
            exists: false, 
            reason: `未在${dirPath}目录下找到JSON文件` 
        };
    } catch (error) {
        console.error(`查找${sourceType}的JSON文件失败:`, error);
        return { exists: false, reason: error.message };
    }
}

/**
 * 检查目录中是否存在JSON文件
 */
async function checkDirectoryForJsonFiles(dirPath) {
    try {
        console.log(`检查目录中的JSON文件: ${dirPath}`);
        
        // 使用Electron的IPC机制读取目录
        const jsonFiles = await scanDirectoryForJsonFiles(dirPath);
        
        if (jsonFiles.length === 0) {
            return { exists: false, reason: '目录中未找到JSON文件' };
        }
        
        // 如果有多个JSON文件，选择最新的
        const latestFile = jsonFiles.reduce((latest, current) => {
            return current.modifiedTime > latest.modifiedTime ? current : latest;
        });
        
        console.log(`找到${jsonFiles.length}个JSON文件，选择最新的: ${latestFile.fileName}`);
        
        return {
            exists: true,
            fileName: latestFile.fileName,
            modifiedTime: latestFile.modifiedTime
        };
    } catch (error) {
        console.error('检查目录JSON文件失败:', error);
        return { exists: false, reason: error.message };
    }
}

/**
 * 扫描目录中的JSON文件
 */
async function scanDirectoryForJsonFiles(dirPath) {
    const jsonFiles = [];
    
    try {
        // console.log(`[DEBUG] 开始扫描目录: ${dirPath}`);
        // 使用fileAPI读取目录
        if (window.fileAPI && window.fileAPI.readDirectory) {
            const files = await window.fileAPI.readDirectory(dirPath);
            // console.log(`[DEBUG] 读取到 ${files.length} 个文件/目录`);
            
            for (const file of files) {
                // console.log(`[DEBUG] 检查文件: ${file.name}, 是否为文件: ${file.isFile}`);
                if (file.isFile && file.name.toLowerCase().endsWith('.json')) {
                    const filePath = `${dirPath}/${file.name}`;
                    jsonFiles.push({
                        exists: true,
                        name: file.name,
                        fileName: file.name,
                        path: filePath,
                        modifiedTime: new Date(file.mtime)
                    });
                    console.log(`[SUCCESS] 找到JSON文件: ${file.name}, 路径: ${filePath}`);
                }
            }
            // console.log(`[DEBUG] 总共找到 ${jsonFiles.length} 个JSON文件`);
        } else {
            throw new Error('fileAPI不可用');
        }
    } catch (error) {
        console.error(`[ERROR] 读取目录失败: ${error.message}`);
        throw error;
    }
    
    return jsonFiles;
}


/**
 * 选择模板文件
 */
async function selectTemplateFile() {
    console.log('selectTemplateFile 函数被调用');
    addLog('模板文件浏览按钮被点击', 'info');
    
    try {
        if (window.fileAPI && window.fileAPI.showOpenDialog) {
            console.log('使用 fileAPI 选择文件');
            const result = await window.fileAPI.showOpenDialog({
                title: '选择Word模板文件',
                filters: [
                    { name: 'Word文档', extensions: ['docx', 'doc'] },
                    { name: '所有文件', extensions: ['*'] }
                ],
                properties: ['openFile']
            });
            
            if (!result.canceled && result.filePaths.length > 0) {
                document.getElementById('techUpdateTemplatePath').value = result.filePaths[0];
                addLog(`已选择模板文件: ${result.filePaths[0]}`, 'info');
            } else {
                addLog('用户取消了文件选择', 'info');
            }
        } else {
            // 如果API不可用，提示用户并使用默认路径
            console.log('fileAPI 不可用，使用默认路径');
            addLog('文件选择API不可用，使用默认模板路径', 'warning');
            const templatePath = 'src/plugins/info-update/tech-update/template.docx';
            document.getElementById('techUpdateTemplatePath').value = templatePath;
            addLog(`已设置默认模板文件: ${templatePath}`, 'info');
        }
    } catch (error) {
        console.error('选择模板文件时出错:', error);
        addLog(`选择模板文件失败: ${error.message}`, 'error');
        // 出错时使用默认路径
        const templatePath = 'src/plugins/info-update/tech-update/template.docx';
        document.getElementById('techUpdateTemplatePath').value = templatePath;
        addLog(`已设置默认模板文件: ${templatePath}`, 'info');
    }
}

/**
 * 选择输出目录
 */
async function selectOutputDirectory() {
    console.log('selectOutputDirectory 函数被调用');
    addLog('输出目录浏览按钮被点击', 'info');
    
    try {
        if (window.fileAPI && window.fileAPI.showOpenDialog) {
            console.log('使用 fileAPI 选择目录');
            const result = await window.fileAPI.showOpenDialog({
                title: '选择输出目录',
                properties: ['openDirectory']
            });
            
            if (!result.canceled && result.filePaths.length > 0) {
                document.getElementById('techUpdateOutputPath').value = result.filePaths[0];
                addLog(`已选择输出目录: ${result.filePaths[0]}`, 'info');
            } else {
                addLog('用户取消了目录选择', 'info');
            }
        } else if (window.fileAPI && window.fileAPI.getDesktopPath) {
            // 如果目录选择API不可用，使用桌面路径
            console.log('目录选择API不可用，使用桌面路径');
            addLog('目录选择API不可用，使用桌面路径', 'warning');
            const desktopPath = await window.fileAPI.getDesktopPath();
            document.getElementById('techUpdateOutputPath').value = desktopPath;
            addLog(`已设置输出目录: ${desktopPath}`, 'info');
        } else {
            // 最后的备选方案
            console.log('所有文件API都不可用');
            addLog('文件API不可用，请手动输入输出路径', 'warning');
            // 尝试使用Node.js的os模块获取桌面路径
            try {
                const os = require('os');
                const desktopPath = os.homedir() + '/Desktop';
                document.getElementById('techUpdateOutputPath').value = desktopPath;
                addLog(`已设置默认输出目录: ${desktopPath}`, 'info');
            } catch (osError) {
                addLog('无法自动获取桌面路径，请手动输入输出路径', 'warning');
            }
        }
    } catch (error) {
        console.error('选择输出目录时出错:', error);
        addLog(`选择输出目录失败: ${error.message}`, 'error');
    }
}

/**
 * 生成技术更新报告
 */
async function generateTechUpdateReport() {
    console.log('Technical Update: generateTechUpdateReport 函数被调用');
    addLog('生成报告按钮被点击', 'info');
    
    const templatePath = document.getElementById('techUpdateTemplatePath').value.trim();
    const outputPath = document.getElementById('techUpdateOutputPath').value.trim();
    
    console.log('Technical Update: 模板路径:', templatePath);
    console.log('Technical Update: 输出路径:', outputPath);
    
    if (!templatePath) {
        addLog('请选择Word模板文件', 'error');
        return;
    }
    
    // 检查是否有检测到的数据源
    const hasDetectedSources = Object.values(detectedDataSources).some(detected => detected);
    if (!hasDetectedSources) {
        addLog('请先检测数据源，确保至少有一个数据源可用', 'error');
        return;
    }
    
    try {
        // 显示进度条
        showProgress(0, '准备生成报告...');
        
        // 收集所有数据
        addLog('开始收集数据...', 'info');
        showProgress(20, '收集数据中...');
        
        const allData = await collectAllData();
        
        showProgress(50, '调用Python脚本处理Word模板...');
        addLog('调用Python脚本处理Word模板...', 'info');
        
        // 调用Python脚本生成Word文档
        const result = await callPythonScript(allData, templatePath, outputPath);
        
        showProgress(90, '处理完成，保存文件...');
        
        if (result.success) {
            showProgress(100, '报告生成完成！');
            addLog('技术更新报告生成成功！', 'success');
            
            // 发送用户使用情况监控数据
            try {
                // 获取用户设置信息（如果可用）
                let userSettings = {};
                if (window.electronAPI && window.electronAPI.getUserSettings) {
                    userSettings = await window.electronAPI.getUserSettings();
                } else if (window.userSettings) {
                    userSettings = window.userSettings;
                } else if (localStorage.getItem('userSettings')) {
                    userSettings = JSON.parse(localStorage.getItem('userSettings'));
                }
                
                // 统计处理的数据源和数据量
                const selectedSources = Object.entries(DATA_SOURCES)
                    .filter(([key, source]) => {
                        const checkbox = document.getElementById(source.checkboxId);
                        return detectedDataSources[key] && checkbox && checkbox.checked;
                    })
                    .map(([key, source]) => source.name);
                
                const monitoringData = {
                    user_name: userSettings.email?.split('@')[0] || 'unknown',
                    user_location: userSettings.site || 'unknown',
                    rpa_id: "142",
                    rpa_name: "tech information update",
                    rpa_version: manifest.version,
                    occurrence: new Date().toLocaleString('en-US', {
                        weekday: 'short',
                        day: '2-digit',
                        month: 'short',
                        year: 'numeric',
                        hour: '2-digit',
                        minute: '2-digit',
                        second: '2-digit',
                        hour12: false
                    }),
                    info: "Technical Update Report Generated Successfully.",
                    extra: `Sources: ${selectedSources.join(', ')}`
                };
                
                const sendMonitoringData = getSendMonitoringData();
                const monitoringResult = await sendMonitoringData([monitoringData]);
                if (monitoringResult.success) {
                    addLog('使用情况数据已记录', 'info');
                } else {
                    addLog(`使用情况数据记录失败: ${monitoringResult.message}`, 'warning');
                }
            } catch (monitoringError) {
                console.error('发送监控数据时出错:', monitoringError);
                addLog(`使用情况数据记录出错: ${monitoringError.message}`, 'warning');
            }
            
            showResult(result.outputFile);
        } else {
            addLog(`报告生成失败: ${result.error}`, 'error');
            hideProgress();
        }
        
    } catch (error) {
        addLog(`生成报告时发生错误: ${error.message}`, 'error');
        hideProgress();
    }
}

/**
 * 收集所有数据源的数据
 */
async function collectAllData() {
    const allData = [];
    
    // 获取日期筛选条件
    const filterYear = document.getElementById('filterYear')?.value || '';
    const filterMonth = document.getElementById('filterMonth')?.value || '';
    
    // 记录筛选条件
    if (filterYear || filterMonth) {
        const filterInfo = [];
        if (filterYear) filterInfo.push(`年份: ${filterYear}`);
        if (filterMonth) filterInfo.push(`月份: ${filterMonth}月`);
        addLog(`应用日期筛选条件: ${filterInfo.join(', ')}`, 'info');
    } else {
        addLog('未设置日期筛选条件，将收集所有数据', 'info');
    }
    
    for (const [key, source] of Object.entries(DATA_SOURCES)) {
        const checkboxElement = document.getElementById(source.checkboxId);
        
        // 只处理检测到且勾选的数据源
        if (detectedDataSources[key] && checkboxElement && checkboxElement.checked) {
            try {
                const rawData = await loadDataFromSource(source.path);
                if (rawData && rawData.length > 0) {
                    // 应用日期筛选
                    const filteredData = filterDataByDate(rawData, filterYear, filterMonth);
                    
                    if (filteredData.length > 0) {
                        // 为每条数据添加来源信息
                        filteredData.forEach(item => {
                            item.source = getSourceRegion(key);
                        });
                        allData.push(...filteredData);
                        
                        if (filterYear || filterMonth) {
                            addLog(`从 ${source.name} 加载了 ${rawData.length} 条数据，筛选后 ${filteredData.length} 条符合条件`, 'info');
                        } else {
                            addLog(`从 ${source.name} 加载了 ${filteredData.length} 条数据`, 'info');
                        }
                    } else {
                        addLog(`从 ${source.name} 加载了 ${rawData.length} 条数据，但筛选后没有符合条件的数据`, 'warning');
                    }
                }
            } catch (error) {
                addLog(`加载 ${source.name} 数据失败: ${error.message}`, 'error');
            }
        } else if (detectedDataSources[key] && checkboxElement && !checkboxElement.checked) {
            addLog(`跳过未勾选的数据源: ${source.name}`, 'info');
        }
    }
    
    if (filterYear || filterMonth) {
        addLog(`应用日期筛选后，总共收集到 ${allData.length} 条符合条件的数据`, 'info');
    } else {
        addLog(`总共收集到 ${allData.length} 条数据`, 'info');
    }
    
    return allData;
}

/**
 * 根据数据源获取地区信息
 */
function getSourceRegion(sourceKey) {
    const regionMap = {
        astm: 'USA',
        govinfo: 'USA',
        cen: 'Europe',
        eucommission: 'Europe'
    };
    return regionMap[sourceKey] || 'Unknown';
}

/**
 * 根据年月筛选数据
 * @param {Array} data - 要筛选的数据数组
 * @param {string} filterYear - 筛选年份（如"2025"），空字符串表示不限制
 * @param {string} filterMonth - 筛选月份（如"06"），空字符串表示不限制
 * @returns {Array} 筛选后的数据数组
 */
function filterDataByDate(data, filterYear, filterMonth) {
    if (!data || !Array.isArray(data)) {
        console.warn('filterDataByDate: 输入数据不是有效数组');
        return [];
    }
    
    // 如果没有设置筛选条件，返回原数据
    if (!filterYear && !filterMonth) {
        console.log('filterDataByDate: 没有设置筛选条件，返回所有数据');
        return data;
    }
    
    console.log(`filterDataByDate: 开始筛选，年份=${filterYear}, 月份=${filterMonth}`);
    
    const filteredData = data.filter(item => {
        // 检查是否有dateOfPublication字段
        if (!item.dateOfPublication) {
            console.log('filterDataByDate: 数据项缺少dateOfPublication字段，跳过');
            return false;
        }
        
        const dateStr = item.dateOfPublication;
        let itemYear = '';
        let itemMonth = '';
        
        // 尝试解析不同格式的日期
        try {
            // 支持多种日期格式：YYYY-MM-DD, YYYY/MM/DD, DD/MM/YYYY, MM/DD/YYYY等
            let parsedDate;
            
            if (dateStr.includes('-')) {
                // YYYY-MM-DD 或 DD-MM-YYYY 格式
                const parts = dateStr.split('-');
                if (parts[0].length === 4) {
                    // YYYY-MM-DD
                    parsedDate = new Date(dateStr);
                } else {
                    // DD-MM-YYYY
                    parsedDate = new Date(`${parts[2]}-${parts[1]}-${parts[0]}`);
                }
            } else if (dateStr.includes('/')) {
                // MM/DD/YYYY 或 DD/MM/YYYY 格式
                const parts = dateStr.split('/');
                if (parts[2].length === 4) {
                    // 假设是MM/DD/YYYY格式
                    parsedDate = new Date(`${parts[2]}-${parts[0].padStart(2, '0')}-${parts[1].padStart(2, '0')}`);
                } else {
                    // 尝试直接解析
                    parsedDate = new Date(dateStr);
                }
            } else {
                // 尝试直接解析其他格式
                parsedDate = new Date(dateStr);
            }
            
            if (isNaN(parsedDate.getTime())) {
                console.warn(`filterDataByDate: 无法解析日期格式: ${dateStr}`);
                return false;
            }
            
            itemYear = parsedDate.getFullYear().toString();
            itemMonth = (parsedDate.getMonth() + 1).toString().padStart(2, '0');
            
        } catch (error) {
            console.warn(`filterDataByDate: 解析日期时出错: ${dateStr}`, error);
            return false;
        }
        
        // 检查年份筛选条件
        if (filterYear && itemYear !== filterYear.toString()) {
            return false;
        }
        
        // 检查月份筛选条件
        if (filterMonth && itemMonth !== filterMonth) {
            return false;
        }
        
        return true;
    });
    
    console.log(`filterDataByDate: 筛选完成，原数据${data.length}条，筛选后${filteredData.length}条`);
    return filteredData;
}

/**
 * 从数据源加载数据
 */
async function loadDataFromSource(sourcePath) {
    try {
        console.log(`开始从数据源加载数据: ${sourcePath}`);
        
        // 构建正确的相对路径
        const relativePath = `src/plugins/info-update/${sourcePath}`;
        console.log(`构建的相对路径: ${relativePath}`);
        
        // 扫描目录中的JSON文件
        const jsonFiles = await scanDirectoryForJsonFiles(relativePath);
        
        if (jsonFiles.length === 0) {
            console.log(`数据源 ${sourcePath} 中没有找到JSON文件`);
            return [];
        }
        
        console.log(`在 ${sourcePath} 中找到 ${jsonFiles.length} 个JSON文件:`, jsonFiles);
        
        // 读取所有JSON文件的数据
        const allData = [];
        
        for (const jsonFile of jsonFiles) {
            try {
                console.log(`正在读取文件: ${jsonFile.path}`);
                const fileResult = await window.fileAPI.readFile(jsonFile.path);
                
                // 检查文件读取结果
                if (!fileResult || !fileResult.success) {
                    throw new Error(`文件读取失败: ${fileResult?.error || '未知错误'}`);
                }
                
                const fileContent = fileResult.data;
                if (!fileContent) {
                    throw new Error('文件内容为空');
                }
                
                // 调试：检查文件内容的类型和内容
                console.log(`文件内容类型: ${typeof fileContent}`);
                console.log(`文件内容是否为字符串: ${typeof fileContent === 'string'}`);
                
                // 确保fileContent是字符串类型
                let contentString;
                if (typeof fileContent === 'string') {
                    contentString = fileContent;
                } else if (fileContent instanceof ArrayBuffer) {
                    // 如果是ArrayBuffer，转换为字符串
                    const decoder = new TextDecoder('utf-8');
                    contentString = decoder.decode(fileContent);
                    console.log('从ArrayBuffer转换为字符串');
                } else if (fileContent instanceof Uint8Array) {
                    // 如果是Uint8Array，转换为字符串
                    const decoder = new TextDecoder('utf-8');
                    contentString = decoder.decode(fileContent);
                    console.log('从Uint8Array转换为字符串');
                } else if (typeof fileContent === 'object' && fileContent !== null) {
                    // 如果是对象，检查是否有content或data属性
                    if (fileContent.content && typeof fileContent.content === 'string') {
                        contentString = fileContent.content;
                        console.log('从对象的content属性获取字符串');
                    } else if (fileContent.data && typeof fileContent.data === 'string') {
                        contentString = fileContent.data;
                        console.log('从对象的data属性获取字符串');
                    } else {
                        // 如果对象没有预期的属性，记录错误并抛出异常
                        console.error('文件读取返回了意外的对象格式:', fileContent);
                        throw new Error(`文件读取返回了意外的对象格式，无法解析为字符串。对象类型: ${Object.prototype.toString.call(fileContent)}`);
                    }
                } else {
                    // 尝试直接转换为字符串，但先检查是否会产生'[object Object]'
                    const stringResult = String(fileContent);
                    if (stringResult === '[object Object]') {
                        console.error('文件读取结果转换为字符串时产生了[object Object]:', fileContent);
                        throw new Error(`文件读取失败: 无法将读取结果转换为有效字符串。原始类型: ${typeof fileContent}`);
                    }
                    contentString = stringResult;
                    console.log('强制转换为字符串');
                }
                
                console.log(`转换后内容长度: ${contentString.length}`);
                console.log(`转换后内容前20个字符: ${JSON.stringify(contentString.substring(0, 20))}`);
                
                // 清理可能的BOM或其他隐藏字符
                let cleanContent = contentString;
                // 移除UTF-8 BOM (EF BB BF)
                if (cleanContent.charCodeAt(0) === 0xFEFF) {
                    cleanContent = cleanContent.substring(1);
                    console.log('检测到并移除了BOM字符');
                }
                
                // 移除开头和结尾的空白字符
                cleanContent = cleanContent.trim();
                
                console.log(`清理后内容前20个字符: ${JSON.stringify(cleanContent.substring(0, 20))}`);
                
                const jsonData = JSON.parse(cleanContent);
                
                // 如果JSON数据是数组，直接添加
                if (Array.isArray(jsonData)) {
                    allData.push(...jsonData);
                } else if (jsonData.data && Array.isArray(jsonData.data)) {
                    // 如果JSON数据有data字段且是数组
                    allData.push(...jsonData.data);
                } else if (jsonData.results && Array.isArray(jsonData.results)) {
                    // 如果JSON数据有results字段且是数组（eucommission格式）
                    allData.push(...jsonData.results);
                } else {
                    // 如果是单个对象，包装成数组
                    allData.push(jsonData);
                }
                
                // 计算实际读取的数据条数
                let dataCount = 1; // 默认为1条（单个对象）
                if (Array.isArray(jsonData)) {
                    dataCount = jsonData.length;
                } else if (jsonData.data && Array.isArray(jsonData.data)) {
                    dataCount = jsonData.data.length;
                } else if (jsonData.results && Array.isArray(jsonData.results)) {
                    dataCount = jsonData.results.length;
                }
                
                console.log(`从 ${jsonFile.name} 读取了 ${dataCount} 条数据`);
            } catch (error) {
                console.error(`读取文件 ${jsonFile.path} 失败:`, error);
                addLog(`读取文件 ${jsonFile.name} 失败: ${error.message}`, 'error');
            }
        }
        
        console.log(`从数据源 ${sourcePath} 总共加载了 ${allData.length} 条数据`);
        return allData;
        
    } catch (error) {
        console.error(`加载数据源 ${sourcePath} 失败:`, error);
        addLog(`加载数据源失败: ${error.message}`, 'error');
        return [];
    }
}

/**
 * 调用Python脚本生成Word文档
 */
async function callPythonScript(data, templatePath, outputPath) {
    try {
        // 准备数据
        const scriptData = {
            data: data,
            templatePath: templatePath,
            outputPath: outputPath
        };
        
        // 将数据写入临时文件以避免命令行参数过长的问题
        const tempDataFile = `temp_data_${Date.now()}.json`;
        const writeFileResult = await window.fileAPI.writeFile(tempDataFile, JSON.stringify(scriptData, null, 2));
        
        console.log('数据已写入临时文件:', writeFileResult);
        addLog(`写入临时文件返回: ${JSON.stringify(writeFileResult)}`, 'info');

        if (!writeFileResult || !writeFileResult.success) {
            addLog('写入临时文件失败', 'error');
            return {
                success: false,
                error: 'Failed to write temporary data file.'
            };
        }
        
        // 调用Python脚本，传递临时文件路径
        const result = await pyAPI.runpyfile({
            scriptPath: './tech_update_word.py',
            pluginName: 'info-update/tech-update',
            args: [tempDataFile] // 传递文件名，而不是写入操作的结果对象
        });
        
        console.log('Python脚本返回结果:', result);
        
        if (result.success) {
            // console.log('Python脚本返回的原始数据:', result.data);
            
            // 检查返回的数据是否为有效的JSON字符串
            if (!result.data || typeof result.data !== 'string') {
                addLog(`Python脚本返回的原始数据: ${JSON.stringify(result)}`, 'error');
                return {
                    success: false,
                    error: 'Python脚本返回的数据格式无效'
                };
            }
            
            try {
                addLog(`准备解析Python脚本返回的数据: ${result.data}`, 'info');
                const parsedResult = JSON.parse(result.data);
                console.log('解析后的结果:', parsedResult);
                
                if (parsedResult.success) {
                    return {
                        success: true,
                        outputFile: parsedResult.output_file
                    };
                } else {
                    return {
                        success: false,
                        error: parsedResult.error || 'Python脚本执行失败'
                    };
                }
            } catch (parseError) {
                console.error('JSON解析错误:', parseError);
                console.error('尝试解析的数据:', result.data);
                return {
                    success: false,
                    error: `JSON解析错误: ${parseError.message}. 原始数据: ${result.data.substring(0, 200)}...`
                };
            }
        } else {
            return {
                success: false,
                error: result.error || '未知错误'
            };
        }
    } catch (error) {
        console.error('调用Python脚本时发生错误:', error);
        
        // 清理临时文件
        if (tempFilePath) {
            try {
                await window.fileAPI.deleteFile(tempFilePath);
                console.log('已清理临时文件:', tempFilePath);
            } catch (cleanupError) {
                console.warn('清理临时文件失败:', cleanupError);
            }
        }
        
        return {
            success: false,
            error: error.message
        };
    }
}

/**
 * 显示进度条
 */
function showProgress(percent, message) {
    const progressContainer = document.getElementById('techUpdateProgressContainer');
    const progressBar = document.getElementById('techUpdateProgressBar');
    const progressText = document.getElementById('techUpdateProgressText');
    
    if (progressContainer) {
        progressContainer.style.display = 'block';
    }
    if (progressBar) {
        progressBar.style.width = `${percent}%`;
    }
    if (progressText) {
        progressText.textContent = `${percent}%`;
    }
    
    if (message) {
        addLog(message, 'info');
    }
}

/**
 * 隐藏进度条
 */
function hideProgress() {
    const progressContainer = document.getElementById('techUpdateProgressContainer');
    if (progressContainer) {
        progressContainer.style.display = 'none';
    }
}

/**
 * 显示结果
 */
function showResult(outputFile) {
    const resultSection = document.getElementById('techUpdateResultSection');
    const resultMessage = document.getElementById('techUpdateResultMessage');
    
    if (resultSection) {
        resultSection.style.display = 'block';
    }
    if (resultMessage) {
        resultMessage.textContent = `技术更新报告已生成: ${outputFile}`;
    }
    
    // 绑定结果按钮事件
    const openResultBtn = document.getElementById('openResultBtn');
    const openFolderBtn = document.getElementById('openFolderBtn');
    
    if (openResultBtn) {
        openResultBtn.onclick = async () => {
            try {
                addLog(`正在打开文件: ${outputFile}`, 'info');
                const result = await window.fileAPI.openFile(outputFile);
                if (result && result.success) {
                    addLog(`文件已打开: ${outputFile}`, 'success');
                } else {
                    addLog(`打开文件失败: ${result?.error || '未知错误'}`, 'error');
                }
            } catch (error) {
                addLog(`打开文件时发生错误: ${error.message}`, 'error');
            }
        };
    }
    
    if (openFolderBtn) {
        openFolderBtn.onclick = async () => {
            try {
                addLog(`正在打开文件夹: ${outputFile}`, 'info');
                const result = await window.fileAPI.showItemInFolder(outputFile);
                if (result && result.success) {
                    addLog(`文件夹已打开: ${outputFile}`, 'success');
                } else {
                    addLog(`打开文件夹失败: ${result?.error || '未知错误'}`, 'error');
                }
            } catch (error) {
                addLog(`打开文件夹时发生错误: ${error.message}`, 'error');
            }
        };
    }
}

/**
 * 重置功能
 */
function resetTechUpdate() {
    // 自动查找并填写Word模板路径
    const defaultTemplatePath = 'src/plugins/info-update/tech-update/template.docx';
    document.getElementById('techUpdateTemplatePath').value = defaultTemplatePath;
    addLog(`已自动设置模板路径: ${defaultTemplatePath}`, 'info');
    
    // 设置默认输出路径为桌面
    const desktopPath = require('os').homedir() + '/Desktop';
    document.getElementById('techUpdateOutputPath').value = desktopPath;
    addLog(`已自动设置输出路径: ${desktopPath}`, 'info');
    
    // 重置日期筛选控件
    const filterYear = document.getElementById('filterYear');
    const filterMonth = document.getElementById('filterMonth');
    
    if (filterYear) {
        filterYear.value = '';
        addLog('已重置年份筛选', 'info');
    }
    
    if (filterMonth) {
        filterMonth.value = '';
        addLog('已重置月份筛选', 'info');
    }
    
    // 重置数据源状态
    Object.values(DATA_SOURCES).forEach(source => {
        const statusElement = document.getElementById(source.statusId);
        const sourceItem = statusElement.closest('.source-item');
        
        statusElement.textContent = '未检测';
        statusElement.className = 'source-status';
        sourceItem.className = 'source-item';
    });
    
    // 清空检测结果
    detectedDataSources = {};
    
    // 隐藏进度条和结果
    hideProgress();
    const resultSection = document.getElementById('techUpdateResultSection');
    if (resultSection) {
        resultSection.style.display = 'none';
    }
    
    // 清空日志
    if (logManager) {
        logManager.clear();
    }
    
    addLog('已重置Technical Update功能并自动设置模板和输出路径，包括日期筛选条件', 'info');
}

/**
 * 添加日志
 */
function addLog(message, type = 'info') {
    if (logManager) {
        logManager.addLog(message, type);
    }
}

// 导出函数供外部调用
if (typeof window !== 'undefined') {
    window.TechUpdate = {
        init: initTechUpdate,
        checkDataSources,
        generateReport: generateTechUpdateReport,
        reset: resetTechUpdate
    };
    
    // 自动初始化Technical Update模块
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', () => {
            console.log('Technical Update: DOM加载完成，开始自动初始化');
            initTechUpdate();
        });
    } else {
        console.log('Technical Update: DOM已加载，立即初始化');
        initTechUpdate();
    }
}

// 如果在模块环境中，导出函数
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        initTechUpdate,
        checkDataSources,
        generateTechUpdateReport,
        resetTechUpdate
    };
}